/**
 * 态势对象数据同步 API 调用模块
 */
import { apiAdminGet, apiAdminPost, apiAdminPut, apiAdminDelete } from './base'

const syncApi = {
  // ============================================================================
  // === 数据源管理 API ===
  // ============================================================================

  /**
   * 创建数据源
   * @param {Object} data - 数据源数据
   * @returns {Promise<Object>}
   */
  createDataSource(data) {
    return apiAdminPost('/api/situation/data-sources', data)
  },

  /**
   * 获取数据源列表
   * @param {Object} params - 查询参数
   * @returns {Promise<Object>}
   */
  getDataSources(params = {}) {
    // 过滤掉 undefined 值，避免传递 "undefined" 字符串到后端
    const filteredParams = {}
    Object.keys(params).forEach(key => {
      if (params[key] !== undefined && params[key] !== null) {
        filteredParams[key] = params[key]
      }
    })
    const queryString = new URLSearchParams(filteredParams).toString()
    const url = queryString ? `/api/situation/data-sources?${queryString}` : '/api/situation/data-sources'
    return apiAdminGet(url)
  },

  /**
   * 获取数据源详情
   * @param {string} id - 数据源ID
   * @returns {Promise<Object>}
   */
  getDataSourceById(id) {
    return apiAdminGet(`/api/situation/data-sources/${id}`)
  },

  /**
   * 更新数据源
   * @param {string} id - 数据源ID
   * @param {Object} data - 更新数据
   * @returns {Promise<Object>}
   */
  updateDataSource(id, data) {
    return apiAdminPut(`/api/situation/data-sources/${id}`, data)
  },

  /**
   * 删除数据源
   * @param {string} id - 数据源ID
   * @returns {Promise<Object>}
   */
  deleteDataSource(id) {
    return apiAdminDelete(`/api/situation/data-sources/${id}`)
  },

  /**
   * 测试数据源连接
   * @param {string} id - 数据源ID
   * @returns {Promise<Object>}
   */
  testConnection(id) {
    return apiAdminPost(`/api/situation/data-sources/${id}/test-connection`)
  },

  /**
   * 获取表结构
   * @param {string} id - 数据源ID
   * @param {string} tableName - 表名
   * @returns {Promise<Object>}
   */
  getTableStructure(id, tableName) {
    return apiAdminGet(`/api/situation/data-sources/${id}/tables/${tableName}/structure`)
  },

  // ============================================================================
  // === 同步任务管理 API ===
  // ============================================================================

  /**
   * 创建同步任务
   * @param {Object} data - 同步任务数据
   * @returns {Promise<Object>}
   */
  createSyncTask(data) {
    return apiAdminPost('/api/situation/sync-tasks', data)
  },

  /**
   * 获取同步任务列表
   * @param {Object} params - 查询参数
   * @returns {Promise<Object>}
   */
  getSyncTasks(params = {}) {
    // 过滤掉 undefined 值，避免传递 "undefined" 字符串到后端
    const filteredParams = {}
    Object.keys(params).forEach(key => {
      if (params[key] !== undefined && params[key] !== null) {
        filteredParams[key] = params[key]
      }
    })
    const queryString = new URLSearchParams(filteredParams).toString()
    const url = queryString ? `/api/situation/sync-tasks?${queryString}` : '/api/situation/sync-tasks'
    return apiAdminGet(url)
  },

  /**
   * 获取同步任务详情
   * @param {string} id - 任务ID
   * @returns {Promise<Object>}
   */
  getSyncTaskById(id) {
    return apiAdminGet(`/api/situation/sync-tasks/${id}`)
  },

  /**
   * 更新同步任务
   * @param {string} id - 任务ID
   * @param {Object} data - 更新数据
   * @returns {Promise<Object>}
   */
  updateSyncTask(id, data) {
    return apiAdminPut(`/api/situation/sync-tasks/${id}`, data)
  },

  /**
   * 删除同步任务
   * @param {string} id - 任务ID
   * @returns {Promise<Object>}
   */
  deleteSyncTask(id) {
    return apiAdminDelete(`/api/situation/sync-tasks/${id}`)
  },

  /**
   * 启用同步任务
   * @param {string} id - 任务ID
   * @returns {Promise<Object>}
   */
  activateSyncTask(id) {
    return apiAdminPost(`/api/situation/sync-tasks/${id}/activate`)
  },

  /**
   * 禁用同步任务
   * @param {string} id - 任务ID
   * @returns {Promise<Object>}
   */
  deactivateSyncTask(id) {
    return apiAdminPost(`/api/situation/sync-tasks/${id}/deactivate`)
  },

  // ============================================================================
  // === 同步执行 API ===
  // ============================================================================

  /**
   * 立即执行同步任务
   * @param {string} id - 任务ID
   * @returns {Promise<Object>}
   */
  executeSyncTask(id) {
    return apiAdminPost(`/api/situation/sync-tasks/${id}/execute`)
  },

  /**
   * 批量执行同步任务
   * @param {Object} data - 请求数据
   * @returns {Promise<Object>}
   */
  batchExecuteSyncTasks(data) {
    return apiAdminPost('/api/situation/sync-execution/batch', data)
  },

  /**
   * 停止同步执行
   * @param {string} executionId - 执行ID
   * @returns {Promise<Object>}
   */
  stopSyncExecution(executionId) {
    return apiAdminPost(`/api/situation/sync-execution/${executionId}/stop`)
  },

  // ============================================================================
  // === 同步日志 API ===
  // ============================================================================

  /**
   * 获取同步日志列表
   * @param {Object} params - 查询参数
   * @returns {Promise<Object>}
   */
  getSyncLogs(params = {}) {
    // 过滤掉 undefined 值，避免传递 "undefined" 字符串到后端
    const filteredParams = {}
    Object.keys(params).forEach(key => {
      if (params[key] !== undefined && params[key] !== null) {
        filteredParams[key] = params[key]
      }
    })
    const queryString = new URLSearchParams(filteredParams).toString()
    const url = queryString ? `/api/situation/sync-logs?${queryString}` : '/api/situation/sync-logs'
    return apiAdminGet(url)
  },

  /**
   * 获取同步日志详情
   * @param {string} id - 日志ID
   * @returns {Promise<Object>}
   */
  getSyncLogById(id) {
    return apiAdminGet(`/api/situation/sync-logs/${id}`)
  },

  // ============================================================================
  // === 统计信息 API ===
  // ============================================================================

  /**
   * 获取同步统计信息
   * @returns {Promise<Object>}
   */
  getStatistics() {
    return apiAdminGet('/api/situation/sync-statistics')
  },

  // ============================================================================
  // === 辅助函数 ===
  // ============================================================================

  /**
   * 格式化数据源配置
   * @param {Object} dataSource - 数据源对象
   * @returns {Object} 格式化后的数据源
   */
  formatDataSource(dataSource) {
    return {
      id: dataSource.id,
      name: dataSource.name,
      description: dataSource.description || '',
      db_type: dataSource.db_type,
      host: dataSource.host,
      port: dataSource.port,
      database_name: dataSource.database_name,
      username: dataSource.username,
      password: '', // 密码不在前端显示
      connection_params: dataSource.connection_params || {},
      is_connected: dataSource.is_connected,
      last_test_time: dataSource.last_test_time,
      test_error: dataSource.test_error,
      created_at: dataSource.created_at,
      updated_at: dataSource.updated_at,
      created_by: dataSource.created_by,
      updated_by: dataSource.updated_by
    }
  },

  /**
   * 格式化同步任务配置
   * @param {Object} task - 同步任务对象
   * @returns {Object} 格式化后的同步任务
   */
  formatSyncTask(task) {
    return {
      id: task.id,
      task_name: task.task_name,
      description: task.description || '',
      data_source_id: task.data_source_id,
      data_source: task.data_source,
      source_table: task.source_table,
      sync_mode: task.sync_mode,
      schedule_expression: task.schedule_expression,
      batch_size: task.batch_size,
      sync_filter: task.sync_filter || '',
      is_active: task.is_active,
      last_sync_time: task.last_sync_time,
      next_sync_time: task.next_sync_time,
      sync_status: task.sync_status,
      total_records: task.total_records,
      synced_records: task.synced_records,
      failed_records: task.failed_records,
      last_error: task.last_error,
      field_mappings: task.field_mappings || [],
      created_at: task.created_at,
      updated_at: task.updated_at,
      created_by: task.created_by,
      updated_by: task.updated_by
    }
  },

  /**
   * 格式化字段映射
   * @param {Object} mapping - 字段映射对象
   * @returns {Object} 格式化后的字段映射
   */
  formatFieldMapping(mapping) {
    return {
      id: mapping.id,
      sync_task_id: mapping.sync_task_id,
      source_field: mapping.source_field,
      target_field: mapping.target_field,
      field_type: mapping.field_type,
      is_required: mapping.is_required,
      default_value: mapping.default_value || '',
      transform_rule: mapping.transform_rule || '',
      created_at: mapping.created_at,
      updated_at: mapping.updated_at
    }
  },

  /**
   * 验证数据源配置
   * @param {Object} dataSource - 数据源配置
   * @returns {Object} 验证结果 {valid: boolean, errors: string[]}
   */
  validateDataSource(dataSource) {
    const errors = []

    if (!dataSource.name || dataSource.name.trim() === '') {
      errors.push('数据源名称不能为空')
    }

    if (!dataSource.db_type) {
      errors.push('请选择数据库类型')
    }

    if (!dataSource.host || dataSource.host.trim() === '') {
      errors.push('数据库主机地址不能为空')
    }

    if (!dataSource.port || dataSource.port <= 0 || dataSource.port > 65535) {
      errors.push('数据库端口号无效')
    }

    if (!dataSource.database_name || dataSource.database_name.trim() === '') {
      errors.push('数据库名称不能为空')
    }

    if (!dataSource.username || dataSource.username.trim() === '') {
      errors.push('用户名不能为空')
    }

    if (!dataSource.password || dataSource.password.trim() === '') {
      errors.push('密码不能为空')
    }

    return {
      valid: errors.length === 0,
      errors
    }
  },

  /**
   * 验证同步任务配置
   * @param {Object} task - 同步任务配置
   * @returns {Object} 验证结果 {valid: boolean, errors: string[]}
   */
  validateSyncTask(task) {
    const errors = []

    if (!task.task_name || task.task_name.trim() === '') {
      errors.push('任务名称不能为空')
    }

    if (!task.data_source_id) {
      errors.push('请选择数据源')
    }

    if (!task.source_table || task.source_table.trim() === '') {
      errors.push('源表名称不能为空')
    }

    if (!task.sync_mode) {
      errors.push('请选择同步模式')
    }

    if (task.sync_mode === 'scheduled' && !task.schedule_expression) {
      errors.push('定时同步模式必须提供定时表达式')
    }

    if (!task.field_mappings || task.field_mappings.length === 0) {
      errors.push('请至少配置一个字段映射')
    }

    if (task.field_mappings) {
      task.field_mappings.forEach((mapping, index) => {
        if (!mapping.source_field || mapping.source_field.trim() === '') {
          errors.push(`第 ${index + 1} 个字段映射的源字段不能为空`)
        }
        if (!mapping.target_field || mapping.target_field.trim() === '') {
          errors.push(`第 ${index + 1} 个字段映射的目标字段不能为空`)
        }
        if (!mapping.field_type || mapping.field_type.trim() === '') {
          errors.push(`第 ${index + 1} 个字段映射的字段类型不能为空`)
        }
      })
    }

    return {
      valid: errors.length === 0,
      errors
    }
  },

  /**
   * 生成定时表达式示例
   * @returns {Array} 定时表达式示例列表
   */
  getCronExpressionExamples() {
    return [
      { label: '每分钟执行', value: '* * * * *' },
      { label: '每小时执行', value: '0 * * * *' },
      { label: '每天凌晨2点执行', value: '0 2 * * *' },
      { label: '每周一凌晨2点执行', value: '0 2 * * 1' },
      { label: '每月1号凌晨2点执行', value: '0 2 1 * *' },
      { label: '工作日（周一到周五）上午9点执行', value: '0 9 * * 1-5' }
    ]
  },

  /**
   * 获取同步状态选项
   * @returns {Array} 同步状态选项列表
   */
  getSyncStatusOptions() {
    return [
      { label: '等待中', value: 'pending', color: 'default' },
      { label: '运行中', value: 'running', color: 'processing' },
      { label: '成功', value: 'success', color: 'success' },
      { label: '失败', value: 'failed', color: 'error' }
    ]
  },

  /**
   * 获取同步模式选项
   * @returns {Array} 同步模式选项列表
   */
  getSyncModeOptions() {
    return [
      { label: '手动同步', value: 'manual', color: 'default' },
      { label: '定时同步', value: 'scheduled', color: 'blue' }
    ]
  },

  /**
   * 获取数据库类型选项
   * @returns {Array} 数据库类型选项列表
   */
  getDatabaseTypeOptions() {
    return [
      { label: 'MySQL', value: 'mysql', color: 'blue' },
      { label: 'PostgreSQL', value: 'postgresql', color: 'green' }
    ]
  },

  /**
   * 获取字段类型选项
   * @returns {Array} 字段类型选项列表
   */
  getFieldTypeOptions() {
    return [
      { label: '字符串', value: 'string' },
      { label: '整数', value: 'integer' },
      { label: '浮点数', value: 'float' },
      { label: '布尔值', value: 'boolean' },
      { label: '日期时间', value: 'datetime' },
      { label: 'JSON', value: 'json' }
    ]
  }
}

export default syncApi